const Service = require('egg').Service;

class JobApplicationService extends Service {
  // 投递简历（业务逻辑不变，仅依赖用户ID）
  async apply(jobId, resumeId, userId) {
    const { ctx } = this;

    // 验证职位存在性
    const job = await ctx.model.Job.findByPk(jobId);
    if (!job) throw new Error('目标职位不存在或已下架');

    // 验证简历存在性及归属权
    const resume = await ctx.model.Resume.findByPk(resumeId);
    if (!resume) throw new Error('简历不存在');
    if (resume.user_id.toString() !== userId.toString()) {
      throw new Error('无权使用此简历（非本人简历）');
    }

    // 防止重复投递
    const existingApplication = await ctx.model.JobApplication.findOne({
      where: { job_id: jobId, user_id: userId, resume_id: resumeId }
    });
    if (existingApplication) throw new Error('已使用该简历投递过此职位，不可重复投递');

    // 创建投递记录
    return ctx.model.JobApplication.create({
      job_id: jobId,
      user_id: userId,
      resume_id: resumeId,
      status: 0, // 0-待审核
      applied_at: new Date()
    });
  }

  // 雇主查看申请（仅依赖职位发布者ID，不校验是否为雇主）
  async getEmployerApplications(employerId, query) {
    const { ctx } = this;
    const { page = 1, pageSize = 10, status } = query;

    // 获取该用户发布的所有职位ID（不校验是否为雇主，只要发布过职位即可）
    const jobs = await ctx.model.Job.findAll({
      where: { publisher_id: employerId },
      attributes: ['job_id']
    });
    const jobIds = jobs.map(job => job.job_id);
    if (jobIds.length === 0) {
      return { list: [], pagination: { page: 1, pageSize: 10, total: 0, totalPages: 0 } };
    }

    // 构建查询条件
    const where = { job_id: jobIds };
    if (status !== undefined) where.status = status;

    // 查询申请列表（不关联其他表，避免模型关联问题）
    const { count, rows } = await ctx.model.JobApplication.findAndCountAll({
      where,
      limit: parseInt(pageSize),
      offset: (parseInt(page) - 1) * parseInt(pageSize),
      order: [['applied_at', 'DESC']]
    });

    return {
      list: rows,
      pagination: {
        page: parseInt(page),
        pageSize: parseInt(pageSize),
        total: count,
        totalPages: Math.ceil(count / pageSize)
      }
    };
  }

  // 求职者查看自己的申请（仅依赖用户ID，不校验是否为求职者）
  async getMyApplications(userId, query) {
    const { ctx } = this;
    const { page = 1, pageSize = 10, status } = query;

    // 构建查询条件（仅筛选当前用户的申请）
    const where = { user_id: userId };
    if (status !== undefined) where.status = status;

    // 查询投递记录
    const { count, rows } = await ctx.model.JobApplication.findAndCountAll({
      where,
      limit: parseInt(pageSize),
      offset: (parseInt(page) - 1) * parseInt(pageSize),
      order: [['applied_at', 'DESC']]
    });

    return {
      list: rows,
      pagination: {
        page: parseInt(page),
        pageSize: parseInt(pageSize),
        total: count,
        totalPages: Math.ceil(count / pageSize)
      }
    };
  }

  // 审核申请（仅验证操作人是否为职位发布者，不校验是否为雇主/管理员）
  async review(applicationId, operatorId, { status, note }) {
    const { ctx } = this;
    console.log('operatorId:', operatorId);

    // 验证申请记录存在性
    const application = await ctx.model.JobApplication.findByPk(applicationId);
    if (!application) throw new Error('申请记录不存在或已删除');

    // 验证职位归属（仅允许职位发布者审核，不限制身份类型）
    const job = await ctx.model.Job.findByPk(application.job_id);
    if (!job) throw new Error('关联职位不存在');
    if (job.publisher_id.toString() !== operatorId.toString()) {
      throw new Error('无权审核此申请（非职位发布者）');
    }

    // 执行审核更新
    return application.update({
      status,
      review_note: note || '',
      reviewed_at: new Date()
    });
  }

  async getAdminApplications(query) {
    const { ctx } = this;
    const {
      page = 1,
      pageSize = 10,
      status,        // 前端传的申请状态（0/1/2，可能为空）
      jobTitle,      // 前端传的职位名称关键词（可能为空）
      applicant      // 前端传的申请人关键词（可能为空）
    } = query;
    const { Op } = ctx.app.Sequelize; // 引入Sequelize操作符

    // 1. 构建主表（JobApplication）的查询条件
    const where = {};
    // 状态筛选：仅当status不为空/undefined时添加（避免筛选空值）
    if (status !== '' && status !== undefined) {
      where.status = Number(status); // 转数字（前端传的是字符串，如"0"，需匹配数据库整数类型）
    }

    // 2. 执行关联查询，添加职位名称、申请人的筛选条件
    const { count, rows } = await ctx.model.JobApplication.findAndCountAll({
      where, // 主表条件（状态）
      include: [
        {
          model: ctx.model.Job,
          as: 'job', // 匹配关联别名
          foreignKey: 'job_id',
          attributes: ['title', 'company'],
          required: true, // 只返回有对应职位的申请（筛选时需关联职位）
          // 职位名称筛选：模糊匹配（包含关键词）
          where: jobTitle
            ? { title: { [Op.like]: `%${jobTitle}%` } } // %表示任意字符，如"前端"→"%前端%"
            : {} // 无关键词时不添加条件
        },
        {
          model: ctx.model.User,
          as: 'applicant', // 匹配关联别名
          foreignKey: 'user_id',
          attributes: ['real_name', 'nickname'],
          required: true, // 只返回有对应申请人的申请（筛选时需关联用户）
          // 申请人筛选：模糊匹配真实姓名 或 昵称
          where: applicant
            ? {
              [Op.or]: [
                { real_name: { [Op.like]: `%${applicant}%` } },
                { nickname: { [Op.like]: `%${applicant}%` } }
              ]
            }
            : {} // 无关键词时不添加条件
        },
        {
          model: ctx.model.Resume,
          as: 'resume',
          foreignKey: 'resume_id',
          attributes: ['file_url'],
          required: false
        }
      ],
      limit: parseInt(pageSize),
      offset: (parseInt(page) - 1) * parseInt(pageSize),
      order: [['applied_at', 'DESC']] // 按申请时间倒序
    });

    // 3. 处理返回数据（保持原有逻辑，补充resume_id）
    const list = rows.map(item => {
      const data = item.toJSON();
      return {
        application_id: data.application_id,
        job_title: data.job?.title || '未知职位',
        company: data.job?.company || '未知公司',
        applicant: data.applicant?.real_name || data.applicant?.nickname || '未知申请人',
        resume_id: data.resume_id || null, // 关键：确保返回resume_id（查看简历用）
        status: data.status,
        applied_at: data.applied_at
      };
    });

    return {
      list,
      pagination: {
        page: parseInt(page),
        pageSize: parseInt(pageSize),
        total: count,
        totalPages: Math.ceil(count / pageSize)
      }
    };
  }
}

module.exports = JobApplicationService;